#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
配置文件管理类
负责读取和解析config.yaml配置文件
"""
import os
import yaml
from readlater.utils.logger import get_logger


class ConfigManager:
    """配置文件管理类"""

    def __init__(self, config_path=None):
        """
        初始化配置管理器

        Args:
            config_path: 配置文件路径，如果为None则使用默认路径
        """
        # 初始化日志记录器
        self.logger = get_logger(__name__)

        # 设置配置文件路径
        if config_path is None:
            # 获取项目根目录
            project_root = os.path.abspath(os.path.join(
                os.path.dirname(__file__), '..', '..'))
            self.config_path = os.path.join(
                project_root, 'config', 'config.yaml')
        else:
            self.config_path = config_path

        # 检查配置文件是否存在
        if not os.path.exists(self.config_path):
            self.logger.error(f"配置文件不存在: {self.config_path}")
            raise FileNotFoundError(f"配置文件不存在: {self.config_path}")

        # 加载配置文件
        self.config = self._load_config()

        # 获取数据目录路径
        project_root = os.path.abspath(os.path.join(
            os.path.dirname(__file__), '..', '..'))
        self.data_dir = os.path.join(project_root, '__data')
        os.makedirs(self.data_dir, exist_ok=True)

    def _load_config(self):
        """
        加载配置文件

        Returns:
            dict: 配置字典
        """
        try:
            with open(self.config_path, 'r', encoding='utf-8') as f:
                config = yaml.safe_load(f)
            self.logger.info(f"成功加载配置文件: {self.config_path}")
            return config
        except yaml.YAMLError as e:
            self.logger.error(f"解析配置文件失败: {str(e)}")
            raise
        except Exception as e:
            self.logger.error(f"加载配置文件失败: {str(e)}")
            raise

    def get_save_path(self):
        """
        获取保存路径

        Returns:
            str: 保存路径
        """
        # 从配置文件中获取保存路径
        save_path = self.config.get(
            'database', {}).get('save_path', 'articles')

        # 如果是相对路径，则转换为绝对路径
        if not os.path.isabs(save_path):
            save_path = os.path.join(self.data_dir, save_path)

        os.makedirs(save_path, exist_ok=True)

        self.logger.debug(f"保存路径: {save_path}")
        return save_path

    def get_database_path(self):
        """
        获取数据库文件路径

        Returns:
            str: 数据库文件路径
        """
        # 从配置文件中获取数据库路径
        db_path = self.config.get('database', {}).get('path', 'read_later.db')

        # 如果是相对路径，则转换为绝对路径
        if not os.path.isabs(db_path):
            db_path = os.path.join(self.data_dir, db_path)

        self.logger.debug(f"数据库路径: {db_path}")
        return db_path

    def is_first_run(self):
        """
        检查是否是首次运行
        首次运行的定义：数据库文件不存在

        Returns:
            bool: 是首次运行返回True，否则返回False
        """
        db_path = self.get_database_path()
        is_first = not os.path.exists(db_path)
        self.logger.debug(f"是否首次运行: {is_first}, DB文件路径：{db_path}")
        return is_first

    def get_chatlog_url(self):
        """
        获取chatlog地址

        Returns:
            str: chatlog地址
        """
        # 从配置文件中获取chatlog地址，如果不存在则返回默认值
        chatlog_url = self.config.get('chatlog', {}).get(
            'url', 'https://example.com/chatlog')
        self.logger.debug(f"Chatlog地址: {chatlog_url}")
        return chatlog_url

    def get_web_server_port(self):
        """
        获取web服务器端口号

        Returns:
            int: 端口号
        """
        port = self.config.get('web', {}).get('port', 8000)
        self.logger.debug(f"Web服务器端口: {port}")
        return port

    def get_siliconflow_api_key(self):
        """
        获取siliconflow API密钥
        优先从环境变量中获取，如果环境变量不存在则从配置文件中获取

        Returns:
            str: API密钥
        """
        # 优先从环境变量中获取
        api_key = os.environ.get('SILICONFLOW_API_KEY')

        # 如果环境变量不存在，则从配置文件中获取
        if not api_key:
            api_key = self.config.get('siliconflow', {}).get('api_key', '')
            # 处理配置文件中的环境变量占位符
            if api_key.startswith('${') and api_key.endswith('}'):
                env_var_name = api_key[2:-1]
                api_key = os.environ.get(env_var_name, '')

        self.logger.debug(
            f"Siliconflow API密钥: {'*' * len(api_key) if api_key else '未设置'}")
        return api_key

    def get_siliconflow_model(self):
        """
        获取siliconflow模型名称

        Returns:
            str: 模型名称
        """
        model = self.config.get('siliconflow', {}).get('model', 'deepseek-ai/DeepSeek-R1-0528-Qwen3-8B')
        self.logger.debug(f"Siliconflow模型: {model}")
        return model

    def get_logging_config(self):
        """
        获取日志配置

        Returns:
            dict: 日志配置字典
        """
        logging_config = self.config.get('logging', {})
        self.logger.debug(f"日志配置: {logging_config}")
        return logging_config

    def get_scraping_config(self):
        """
        获取网页抓取配置

        Returns:
            dict: 网页抓取配置字典
        """
        scraping_config = self.config.get('scraping', {})
        self.logger.debug(f"网页抓取配置: {scraping_config}")
        return scraping_config

    def get(self, key, default=None, env_var=False):
        """
        获取指定的配置项
        支持点表示法访问嵌套配置，如 'wechat.target_user'

        Args:
            key: 配置项键名
            default: 默认值

        Returns:
            配置项值或默认值
        """
        # 处理点表示法
        parts = key.split('.')
        value = self.config

        try:
            for part in parts:
                value = value[part]
            self.logger.debug(f"获取配置项 '{key}': {value}")
            
            if env_var and isinstance(value, str) and value.startswith('${') and value.endswith('}'):
                # 处理配置文件中的环境变量占位符
                env_var_name = value[2:-1]
                value = os.environ.get(env_var_name, '')
            
            return value
        except (KeyError, TypeError):
            self.logger.debug(f"配置项 '{key}' 不存在，返回默认值: {default}")
            return default


# 测试代码
if __name__ == '__main__':
    try:
        # 初始化配置管理器
        config_manager = ConfigManager()

        # 测试获取数据库路径
        print(f"数据库路径: {config_manager.get_database_path()}")

        # 测试是否首次运行
        print(f"是否首次运行: {config_manager.is_first_run()}")

        # 测试获取chatlog地址
        print(f"Chatlog地址: {config_manager.get_chatlog_url()}")

        # 测试获取web服务器端口
        print(f"Web服务器端口: {config_manager.get_web_server_port()}")

        # 测试获取siliconflow API密钥
        print(f"Siliconflow API密钥: {config_manager.get_siliconflow_api_key()}")

        # 测试获取siliconflow模型
        print(f"Siliconflow模型: {config_manager.get_siliconflow_model()}")

    except Exception as e:
        print(f"测试失败: {str(e)}")
